package com.pagepub.core.utils;

import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;

public class ExtendString {
	/**
	 * 加密/解密时所用的字符串
	 * 
	 */
	private static String key = "wingroupisaverygoodenpricedoyouthinkso";

	/**
	 * 函数名称：replace 函数功能：字符替换，可以把指定字符串的的一个旧字符串换成新的字符串
	 * 
	 * @param sList
	 *            要替换的字符串
	 * 
	 * @param oldString
	 *            要被替换的字串
	 * 
	 * @param newString
	 *            新的字串
	 * @return 返回替换後的结果
	 */
	public static String replace(String sList, String oldString,
			String newString) {
		if (sList == null || oldString == null) {
			return sList;
		}
		if (sList.equals("") || oldString.equals("")) {
			return sList;
		}
		String resultString = "";
		int stringAtLocal = sList.indexOf(oldString); // 旧字符串的开始位置

		int startLocal = 0; // 本次替换的开始范围

		while (stringAtLocal >= 0) {
			resultString = resultString
					+ sList.substring(startLocal, stringAtLocal) + newString;
			startLocal = stringAtLocal + oldString.length();
			stringAtLocal = sList.indexOf(oldString, startLocal);
		}
		resultString = resultString
				+ sList.substring(startLocal, sList.length());
		return resultString;
	}

	/**
	 * 全部替换字符串里符合指定内容的为其它内容，与String类中不同，它使用的不是正则表达式的。
	 * 
	 * @param String
	 *            regex, 需要替换的内容
	 * @param String
	 *            replacement, 用来替换的内容
	 * 
	 * @return String, 字符串替换后的内容
	 * 
	 */
	public static String replaceAll(String str, String regex, String replacement) {
		StringBuffer sb = new StringBuffer();
		int rbegin = 0;
		int rend = str.indexOf(regex);
		int rlen = regex.length();
		while (rend >= 0) {
			sb.append(str.substring(rbegin, rend));
			sb.append(replacement);
			rbegin = rend + rlen;
			rend = str.indexOf(regex, rbegin);
		}
		sb.append(str.substring(rbegin));
		str = sb.toString();
		return str;
	}

	/**
	 * 函数名称：split 函数功能：分割字符串的函数
	 * 
	 * @param sList
	 *            待分割的字串
	 * @param splitChar
	 *            分割标志串
	 * 
	 * @param result
	 *            存放结果的数组指针
	 * 
	 * @return 分割後数组中的元素个数
	 * 
	 */
	public static int split(String sList, String splitChar, String result[]) {
		// 如果没有传入源串或分割标志串(splitChar)，则返回
		if (sList == null || sList.equals("") || splitChar == null
				|| splitChar.equals("")) {
			result[0] = sList;
			return 1;
		}
		int stringAtLocal = sList.indexOf(splitChar); // 旧字符串的开始位置

		int startLocal = 0; // 本次替换的开始范围

		int resultCount = 1; // 分割结果数的计数器

		while (stringAtLocal >= 0) {
			result[resultCount - 1] = sList
					.substring(startLocal, stringAtLocal);
			startLocal = stringAtLocal + splitChar.length();
			stringAtLocal = sList.indexOf(splitChar, startLocal);
			resultCount++;
		}
		result[resultCount - 1] = sList.substring(startLocal, sList.length());
		return resultCount;
	}

	/**
	 * 函数名称：CToN 函数功能：把中文数字转 换成阿拉伯数字
	 * 
	 * @param C
	 *            待转换中文数字
	 * 
	 * @return 转换後的阿拉伯数字串
	 */
	public static String CToN(String C) {
		if (C == null) {
			return "";
		}
		String result = "";
		String cStr = "Ｏ○ｏ０１２３４５６７８９一二三四五六七八九oO";
		String nStr = "000012345678912345678900";
		char temp;
		for (int i = 0; i < C.length(); i++) {
			temp = C.charAt(i);
			if (cStr.indexOf(String.valueOf(temp)) >= 0) {
				result = result
						+ String.valueOf(nStr.charAt(cStr.indexOf(String
								.valueOf(temp))));
			} else if (String.valueOf(temp).equals("十")) { // 如果"十"是最後一字或者後面的一个字不是数字，则加一个0
				if (i >= C.length() - 1
						|| cStr.indexOf(String.valueOf(C.charAt(i + 1))) < 0) {
					result += "0";
				}
				if (i == 0 || cStr.indexOf(String.valueOf(C.charAt(i - 1))) < 0) {
					result += "1";
				}
			} else {
				result += temp;
			}
		}
		return result;
	}

	/**
	 * 函数名称：NToC 函数功能：把阿拉伯数字转 换成中文数字
	 * 
	 * @param N
	 *            待转换阿拉伯数字
	 * @return 转换後的中文数字串
	 * 
	 */
	public static String NToC(String N) {
		if (N == null) {
			return "";
		}
		String result = "";
		String cStr = "一二三四五六七八九十零";
		String nStr = "12345678900";
		char temp;
		for (int i = 0; i < N.length(); i++) {
			temp = N.charAt(i);
			if (nStr.indexOf(String.valueOf(temp)) >= 0) {
				result = result
						+ String.valueOf(cStr.charAt(nStr.indexOf(String
								.valueOf(temp))));
			} else {
				result += temp;
			}
		}
		return result;
	}

	/**
	 * 函数名称：NToNC 函数功能：把阿拉伯数字转 全形数字
	 * 
	 * @param N
	 *            待转换阿拉伯数字
	 * @return 转换後的全形数字
	 */
	public static String NToNC(String N) {
		if (N == null) {
			return "";
		}
		String result = "";
		String cStr = "０１２３４５６７８９";
		String nStr = "0123456789";
		char temp;
		for (int i = 0; i < N.length(); i++) {
			temp = N.charAt(i);
			if (nStr.indexOf(String.valueOf(temp)) >= 0) {
				result = result
						+ String.valueOf(cStr.charAt(nStr.indexOf(String
								.valueOf(temp))));
			} else {
				result += temp;
			}
		}
		return result;
	}

	/**
	 * 函数名称：nullToSpace 函数功能：去除字符串空值
	 * 
	 * @param s1
	 *            待加工的字符串
	 * 
	 * @return 如果传入参数是null返回空串"",否则原字串去空格後返回
	 * 
	 */
	public static String nullToSpace(String s1) {

		if (s1 == null || s1.equals("null")) {
			return "";
		}
		return s1.trim();
	}

	/**
	 * 函数名称：nullToSpace 函数功能：去除字符串空值
	 * 
	 * @param s1
	 *            待加工的字符串
	 * 
	 * @return 如果传入参数是null返回空串"",否则原字串去空格後返回
	 * 
	 */
	public static String nullToSpaceNoTrim(String s1) {

		if (s1 == null || s1.equals("null")) {
			return "";
		}
		return s1;
	}

	/**
	 * 函数名称：nullToZero 函数功能：将空值转为0
	 * 
	 * @param s1
	 *            待加工的字符串
	 * 
	 * @return 如果传入参数是null返回空串"",否则原字串去空格後返回
	 * 
	 */
	public static String nullToZero(String s1) {
		if (s1 == null || s1.equals("")) {
			return "0";
		}
		return s1.trim();
	}

	/**
	 * 函数名称：toSql 函数功能：'-->'' 适用范围：把sql语句中的'转化位''
	 * 
	 * @param str
	 *            待转换的字符串
	 * 
	 * @return 转换後的字串
	 */
	public static String toSql(String str) {
		if (str == null || str.equals("") || str.equals("null")) {
			return "";
		} else {
			str = toHtml(str);
			return replace(str, "'", "''");
		}
	}

	/**
	 * 函数名称：toSql1 函数功能：'-->'' 适用范围：把sql语句中的'转化位''
	 * 
	 * @param str
	 *            待转换的字符串
	 * 
	 * @return 转换後的字串
	 */
	public static String toSql1(String str) {
		if (str == null || str.equals("") || str.equals("null")) {
			return "";
		} else {
			return replace(str, "'", "''");
		}
	}

	/**
	 * 函数名称：toSql2 函数功能：'-->'' 适用范围：把sql语句中的'转化位''
	 * 
	 * @param str
	 *            待转换的字符串
	 * 
	 * @return 转换後的字串
	 */
	public static String toSql2(String str) {
		if (str == null || str.equals("") || str.equals("null")) {
			return " ";
		} else {
			str = toHtml(str);
			return replace(str, "'", "''");
		}
	}

	/**
	 * 函数名称：forTuiJianCard 函数功能："-->“
	 * 
	 * 适用范围：把str语句中的"转化位”
	 * 
	 * @param str
	 *            待转换的字符串
	 * 
	 * @return 转换後的字串
	 */
	public static String forTuiJianCard(String str) {
		String chrs = "";
		try {
			int l = str.length();
			for (int i = 0; i < l; i++) {
				char chr = str.charAt(i);
				switch (chr) {
				case '"':
					chrs = chrs + "“";
					break;
				case '\\':
					chrs = chrs + "\\\\";
					break;

				default:
					chrs = chrs + chr;
				}
			}

		} catch (Exception ex) {
			return null;
		}
		str = chrs;
		return chrs;
	}

	/**
	 * 函数名称：toHtml 函数功能：把数据库的内容转化为相应的html语言
	 * 
	 * @param str
	 *            待转换的字符串
	 * 
	 * @return 转换後的字串
	 */
	public static String toHtml(String str) {
		String chrs = "";
		try {
			int l = str.length();
			for (int i = 0; i < l; i++) {
				char chr = str.charAt(i);
				switch (chr) {
				case '<':
					chrs = chrs + "&lt;";
					break;
				case '>':
					chrs = chrs + "&gt;";
					break;
				case '"':
					chrs = chrs + "&quot;";
					break;
				default:
					chrs = chrs + chr;
				}
			}

		} catch (Exception ex) {
			return null;
		}
		str = chrs;
		return chrs;
	}

	/**
	 * 函数名称：encrypt 函数功能：加密
	 * 
	 * @param str
	 *            待转换的字符串
	 * 
	 * @return 转换後的字串
	 */
	public static String encrypt(String str) {
		int strLen = str.length();
		String retuValue = "";
		int keyIndex = 0;
		for (int strIndex = 0; strIndex < strLen; strIndex++) {
			while (keyIndex < key.length()) {
				retuValue += (char) ((int) str.charAt(strIndex) ^ (int) key
						.charAt(keyIndex));
				keyIndex++;
				if (keyIndex == key.length() - 1) {
					keyIndex = 0;
				}
				break;
			}
		}
		return retuValue;
	}

	/**
	 * 函数名称：encrypt 函数功能：解密
	 * 
	 * @param str
	 *            待转换的字符串
	 * 
	 * @return 转换後的字串
	 */
	public static String decrypt(String str) {
		int strLen = str.length();
		String retuValue = "";
		int keyIndex = 0;
		for (int strIndex = 0; strIndex < strLen; strIndex++) {
			while (keyIndex < key.length()) {
				retuValue += (char) ((int) str.charAt(strIndex) ^ (int) key
						.charAt(keyIndex));
				keyIndex++;
				if (keyIndex == key.length() - 1) {
					keyIndex = 0;
				}
				break;
			}
		}
		return retuValue;
	}

	/**
	 * 函数名称：strArray2IntArray 函数功能:把字符型数组转换为整型数组
	 * 
	 * @param strArray
	 *            字符型数组
	 * 
	 * @return 整型数组
	 */
	public static int[] strArray2IntArray(String[] strArray) {
		if (strArray == null) {
			return null;
		}
		int[] intArray = new int[strArray.length];
		try {
			for (int i = 0; i < strArray.length; i++) {
				intArray[i] = Integer.parseInt(strArray[i]);
			}
		} catch (Exception ex) {
			System.out.println(ex.toString());
		}
		return intArray;
	}

	/**
	 * 函数名称：arrayToStr 函数功能:把数组转换为字符串列表
	 * 
	 * @param array1
	 *            数组
	 * @return 用","隔开的字符串列表
	 */
	public static String arrayToStr(String[] array1) {
		String sResult = "";
		if (array1 == null) {
			return sResult;
		}
		for (int i = 0; i < array1.length; i++) {
			if ("".equals(sResult)) {
				sResult = array1[i];
			} else {
				sResult += "," + array1[i];
			}
		}
		return sResult;
	}

	/**
	 * 函数名称：arrayToStr 函数功能:把数组转换为字符串列表
	 * 
	 * @param array1
	 *            数组
	 * @param splitChar
	 *            分隔符
	 * 
	 * @return 用splitChar隔开的字符串列表
	 */
	public static String arrayToStr(String[] array1, String splitChar) {
		String sResult = "";
		if (array1 == null) {
			return sResult;
		}
		for (int i = 0; i < array1.length; i++) {
			if ("".equals(sResult)) {
				sResult = array1[i];
			} else {
				sResult += splitChar + array1[i];
			}
		}
		return sResult;
	}

	/**
	 * 函数名称：arrayToStr 函数功能:把数组转换为字符串列表
	 * 
	 * @param array1
	 *            数组
	 * @return 用","隔开的字符串列表
	 */
	public static String arrayToStr(int[] array1) {
		return arrayToStr(array1, ",");
	}

	/**
	 * 函数名称：arrayToStr 函数功能:把数组转换为字符串列表
	 * 
	 * @param array1
	 *            数组
	 * @param splitChar
	 *            分隔符
	 * 
	 * @return 用splitChar隔开的字符串列表
	 */
	public static String arrayToStr(int[] array1, String splitChar) {
		String sResult = "";
		if (array1 == null) {
			return sResult;
		}
		for (int i = 0; i < array1.length; i++) {
			if ("".equals(sResult)) {
				sResult = String.valueOf(array1[i]);
			} else {
				sResult += splitChar + String.valueOf(array1[i]);
			}
		}
		return sResult;
	}

	/**
	 * 函数名称：getNum 函数功能:取得str中的数字
	 * 
	 * @param str
	 * @return 数字字符串
	 * 
	 */
	public static String getNum(String str) {
		try {
			if (str == null || (str.trim()).length() < 1) {
				return "";
			}
			String temp = "0123456789";
			String tempString = "";
			String string = "";
			for (int i = 0; i < str.length(); i++) {
				tempString = str.substring(i, i + 1);
				if (temp.indexOf(tempString) > -1) {
					string += tempString;
				}
			}
			return string;
		} catch (Exception ex) {
			ex.printStackTrace();
			return "";
		}
	}

	/**
	 * 函数名称：getCharNum 函数功能:取得分割符的个数
	 * 
	 * @param sList
	 *            用分割符隔开的字符串列表
	 * @param splitChar
	 *            分割符
	 * 
	 * @return 分割符的个数
	 */
	public static int getCharNum(String sList, String splitChar) {
		// 如果没有传入源串或分割标志串(splitChar)，则返回-1
		if (sList == null || sList.equals("") || splitChar == null
				|| splitChar.equals("")) {
			return -1;
		}
		int StringAtLocal = sList.indexOf(splitChar); // 旧字符串的开始位置

		int StartLocal = 0; // 本次替换的开始范围

		int iCount = 0; // 分割结果数的计数器

		while (StringAtLocal >= 0) {
			StartLocal = StringAtLocal + splitChar.length();
			StringAtLocal = sList.indexOf(splitChar, StartLocal);
			iCount++;
		}
		return iCount;
	}

	/**
	 * 函数名称：strToArray 函数功能:根据分割符把字符串列表分割,并存入到数组
	 * 
	 * @param sList
	 *            用分割符隔开的字符串列表
	 * @param splitChar
	 *            分割符
	 * 
	 * @return 数组
	 */
	public static String[] strToArray(String sList, String splitChar) {
		if (sList == null) {
			return null;
		}
		int iCount = getCharNum(sList, splitChar); // splitChar的个数

		if (iCount == -1) {
			return null;
		}
		iCount++;
		int StringAtLocal = sList.indexOf(splitChar); // 旧字符串的开始位置

		int StartLocal = 0; // 本次替换的开始范围

		String[] aResult = new String[iCount];
		if (iCount == 1) {
			StringAtLocal = sList.length();
		}
		aResult[0] = sList.substring(StartLocal, StringAtLocal);
		for (int i = 1; i < iCount; i++) {
			StartLocal = StringAtLocal + splitChar.length();
			StringAtLocal = sList.indexOf(splitChar, StartLocal);
			if (StringAtLocal == -1) {
				StringAtLocal = sList.length();
			}
			aResult[i] = sList.substring(StartLocal, StringAtLocal);
		}
		return aResult;
	}

	/**
	 * 函数名称：strToArray 函数功能：判断一个字节是否在0到9之间
	 * 
	 * @param cCheck
	 *            字节
	 * @exception IsDigit
	 *                返回false
	 * @throws IsDigit
	 *             无
	 * 
	 * @see isNums
	 * @return 在0到9之间，则返回true
	 */
	private static boolean IsDigit(char cCheck) {
		return (('0' <= cCheck) && (cCheck <= '9'));
	}

	/**
	 * 函数名称：isNums 函数功能：判断一个字符串是否是数字
	 * 
	 * @param str1
	 *            字符串
	 * 
	 * @exception IsDigit
	 *                返回false *
	 * @return 是数字，则返回true
	 */
	public static boolean isNums(String str1) {
		try {
			char cCheck;
			for (int i = 0; i < str1.length(); i++) {
				cCheck = str1.charAt(i);
				if (!IsDigit(cCheck)) {
					return false;
				}
			}
			return true;
		} catch (Exception ex) {
			ex.printStackTrace();
			return false;
		}
	}

	/**
	 * 函数名称：getNumToInt 函数功能：把一个数字字符串转变为整型
	 * 
	 * 例:034-->34,23.3--->23,0023.4--23
	 * 
	 * @param str1
	 *            数字字符串
	 * 
	 * @exception IsDigit
	 *                返回-1 *
	 * @return 是数字，则返回整型，否则返回-1
	 */
	public static int getNumToInt(String str1) {
		try {
			if (str1 == null || "".equals(str1)) {
				str1 = "0";
			}
			int flag = 0; // 如果遇到不为零时，flag置1
			String tmpStr = ""; // 存放去掉开头零的字符串
			char cCheck;
			for (int i = 0; i < str1.length(); i++) {
				cCheck = str1.charAt(i);
				if (!IsDigit(cCheck)) {
					break;
				}
				if (cCheck != '0') {
					flag = 1;
				}
				if (cCheck == '0' && flag == 0) {
					continue;
				}
				tmpStr += String.valueOf(cCheck);
			}
			// 假如传入参数为“0”，则tmpStr这时为空
			if ("".equals(tmpStr)) {
				tmpStr = "0";
			}
			return Integer.parseInt(tmpStr);
		} catch (Exception ex) {
			return -1;
		}
	}

	/**
	 * 函数名称：getNumToInt 函数功能：把一个字符串的前length位加值（inscrease）
	 * 
	 * @param str1
	 *            数字字符串
	 * 
	 * @param length
	 *            设定字符串的长度
	 * @param inscrease
	 *            转换成数字後的增加值
	 * 
	 * @exception IsDigit
	 *                返回"-1"
	 * @return 则返回字符串，否则返回-1
	 */
	public static String getChangeFormatString(String str1, int length,
			int inscrease) {
		try {
			if (length < 1) {
				return "error:参数length<1";
			}
			if (str1 == null) {
				str1 = "";
			}
			String frontStr = ""; // 前length位字符

			if (str1.length() > length) {
				frontStr = str1.substring(0, length);
			} else {
				frontStr = str1;
			}
			if (length <= 0) {
				frontStr = str1; // length<=0时，取原长度
			}
			int maxNum = getNumToInt(frontStr);
			if (maxNum == -1) {
				return "error:字符串不全部是数字";
			}
			maxNum += inscrease;
			if (maxNum <= 0) {
				return "error:参数inscrease取值太小";
			}
			String retStr = String.valueOf(maxNum);
			for (int i = 0; i < length - String.valueOf(maxNum).length(); i++) {
				retStr = "0" + retStr;
			}
			if (str1.length() > length) {
				retStr += str1.substring(length, str1.length());
			}
			return retStr;
		} catch (Exception ex) {
			return "";
		}
	}

	/**
	 * 函数名称：strIncOne 函数功能:加一运算
	 * 
	 * <pre>
	 * 例:s1=000123,则+1後变为000124;
	 * </pre>
	 * 
	 * @param s1
	 *            要加1的源值,前面可以带零
	 * @return 加1後的值
	 * 
	 */
	public static String strIncOne(String s1) {
		String sResult = "";
		try {
			sResult = getChangeFormatString(s1, s1.length(), 1);
		} catch (Exception ex) {
			return "";
		}
		return sResult;
	}

	/**
	 * 函数名称：addZero<br>
	 * 函数功能：在字符串str1的前面加上strl.length-iLen个零
	 * 
	 * @return 格式化后的字符串
	 */
	public static String addZero(String str1, int iLen) {
		if (str1 == null) {
			return null;
		}
		String sReturnStr = str1;
		for (int i = 0; i < iLen - str1.length(); i++) {
			sReturnStr = "0" + sReturnStr;
		}
		return sReturnStr;
	}

	/**
	 * 函数名称：returnToBr<br>
	 * 函数功能：转化字符串中的空格、换行
	 * 
	 * @return 格式化后的字符串
	 */
	public static String returnToBr(String s) {
		if (s == null || s.equals("")) {
			return s;
		}
		StringBuffer stringbuffer = new StringBuffer();
		for (int i = 0; i < s.length(); i++) {
			if (s.charAt(i) == '\n') {
				stringbuffer = stringbuffer.append("<br>");
			} else if (s.charAt(i) == '\r') {
				stringbuffer = stringbuffer.append("&nbsp;");
			} else if (s.charAt(i) == ' ') {
				stringbuffer = stringbuffer.append("&nbsp;");
			} else {
				stringbuffer.append(s.substring(i, i + 1));

			}
		}
		String s1 = stringbuffer.toString();
		return s1;
	}

	/**
	 * 去掉字符串两端的空白字符,并将字符串转化为中国的标准字符gb2312的字符串.
	 */
	public static String CS(String str) { // 去掉字符串2端的空白字符
		try {
			if (str == null) {
				return "";
			}
			str = new String(str.getBytes("8859_1"), "GBK");
		} catch (Exception e) {
			System.out.println(e);
		}
		return str;
	}

	public static String trim(String str) { // 去掉字符串2端的空白字符
		try {
			if (str == null) {
				return null;
			}
			str = str.trim();
			if (str == null) {
				return null;
			}
			return str;
		} catch (Exception e) {
			System.out.println(e);
		}
		return str;
	}

	public static String trimAll(String str) {
		return str = trim(str).replaceAll(" ", "");
	}

	/**
	 * 去掉字符串两端的空白字符转化为中国的标准字符集合。
	 * 
	 */
	public static String CS2(String str) { // 去掉字符串2端的空白字符
		try {
			if (str == null) {
				return null;
			}
			str = str.trim();
			if (str == null) {
				return null;
			}
			str = new String(str.getBytes("8859_1"), "gb2312");
		} catch (Exception e) {
			System.out.println(e);
		}
		return str;
	}

	/**
	 * 去掉字符串两端的空白字符, 转化为指定的字符集转化为另一个的标准字符集合。
	 * 
	 */
	public static String CS2(String str, String srcCharset, String ObjCharset) {
		try {
			if (str != null) {
				str = str.trim();
				if (str != null) {
					str = new String(str.getBytes(srcCharset), ObjCharset);
				}
			}
		} catch (Exception e) {
			System.out.println(e);
		}
		return str;
	}

	/**
	 * 不去掉字符串两端的空白字符, 转化为指定的字符集转化为另一个的标准字符集合。
	 * 
	 */
	public static String CS2noTrim(String str, String srcCharset,
			String ObjCharset) {
		try {
			if (str != null) {
				str = new String(str.getBytes(srcCharset), ObjCharset);
			}
		} catch (Exception e) {
			System.out.println(e);
		}
		return str;
	}

	public static String encryptPWD(String sPassword) {
		byte cResult[] = new byte[16];
		String sResult = "";
		try {
			MessageDigest md = MessageDigest.getInstance("MD5");
			md.update(("yuanlixin.fjrstpj" + sPassword).getBytes());
			cResult = md.digest();

			for (int i = 0; i < cResult.length; i++) {
				if (cResult[i] < 0) {
					cResult[i] += 128;
				}
				String sTemp = Integer.toHexString(cResult[i]).toUpperCase();
				if (cResult[i] < 16) {
					sTemp = "0" + sTemp;
				}
				sResult += sTemp;
			}
		} catch (Exception e) {
			sResult = "";
		}
		return sResult;
	} // end public String EncryptPWD(String sPassword)

	// 检查数字

	public static boolean checkNum(String field) {
		try {
			String valid = "0123456789";
			String valid2 = "-0123456789";
			String temp = "";
			boolean have = true;
			if (field == null || field.equals("") || field.equals("null")) {
				have = false;
			} else {
				field = field.trim();
				temp = "" + field.substring(0, 1);
				if (valid2.indexOf(temp) == -1) {
					// 第一个字符可以是负号。

					return false;
				}
				for (int i = 1; i < field.length(); i++) {
					temp = "" + field.substring(i, i + 1);
					if (valid.indexOf(temp) == -1) {
						have = false;
					}
				}
			}
			return have;
		} catch (Exception ex) {
			ex.printStackTrace();
			return false;
		}
	}

	/**
	 * 函数名称：parseInt 函数功能：把数字字符串转换为整形
	 * 
	 * @param str
	 *            待转换的字符串
	 * 
	 * @return 如果为数字字符串转换为数字，否则返回0。
	 * 
	 */

	public static int parseInt(String str) {
		try {

			if (checkNum(str)) {
				str = str.trim();
				return Integer.parseInt(str);
			} else {
				return 0;
			}

		} catch (Exception ex) {
			return 0;
		}
	}

	/**
	 * 函数名称：toHtml 函数功能：把数据库的内容转化为相应的html语言
	 * 
	 * @param str
	 *            待转换的字符串
	 * 
	 * @return 转换後的字串
	 */
	public static String toHtml2(String str) {
		try {
			char ch;
			int length = 0;
			String temp = "";
			if (str != null) {
				str = str.trim();
				if (str.length() != 0) {
					length = str.length();
					// out.println(length);
					for (int i = 0; i < length; i++) {
						ch = str.charAt(i);
						switch (ch) {
						case (char) 13:
							temp = temp + "<br>"; // 回车
							break;
						case (char) 34:
							temp = temp + "&quot;"; // 双引号

							break;
						case (char) 32:
							if (i < length) {
								if (str.charAt(i + 1) == ((char) 32)
										|| str.charAt(i + 1) == ((char) 9)
										|| str.charAt(i - 1) == ((char) 32)
										|| str.charAt(i - 1) == ((char) 9)) {
									temp = temp + "&nbsp;";
								} else {
									temp = temp + " ";
								}
							} else {
								temp = temp + "&nbsp;";
							}
							break;
						case (char) 9:
							temp = temp + "&nbsp;";
							break;
						case '<':
							temp = temp + "&lt;";
							break;
						case '>':
							temp = temp + "&gt;";
							break;
						default:
							temp = temp + ch;
						} // switch
					} // for
				}
				str = temp;
			} else {
				str = "";
			}
			return str;
		} catch (Exception ex) {
			return null;
		}
	}

	/**
	 * 获取一个字符串的绝对长度(如果遇到汉字字符则算两个)
	 * 
	 * @param s
	 *            传入的字串
	 * 
	 * @return 字串的绝对长度
	 * 
	 */
	public static int absoluteLength(String s) {
		if (s == null) {
			return 0;
		}
		try {
			return new String(s.getBytes("GBK"), "8859_1").length();
		} catch (Exception e) {
			return s.length();
		}
	}

	/**
	 * 将一字符串按指定长度进行换行
	 * 
	 * @param s
	 *            传入的字串
	 * 
	 * @param len :
	 *            the length to newline
	 * @return new string
	 */
	public static String strByNewline(String s, int len) {
		if (s == null || "".equals(s)) {
			return "";
		}

		try {

			int len1 = absoluteLength(s);
			if (len1 <= len) {
				return s;
			}
			char ch;
			char ch1 = 13; // 回车

			int tempLen = 0; // 行字符数
			int len2 = s.length();
			String newStr = "";
			for (int i = 0; i < len2; i++) {
				ch = s.charAt(i);
				if (ch == ch1) {
					tempLen = 0;
				} else if (ch <= 256) {
					tempLen++;
				} else if (ch > 256) {
					tempLen = tempLen + 2;
				}

				if (tempLen < len - 1) {
					newStr += ch;
				} else {
					newStr += ch;
					newStr += ch1;
					tempLen = 0;
				}
			}
			return newStr;
			// 只有英文
		} catch (Exception ex) {
			return null;
		}
	}

	/**
	 * 将一字符串按指定长度进行换行
	 * 
	 * @param s
	 *            传入的字串
	 * 
	 * @param len :
	 *            the length to newline
	 * @return new string
	 */
	public static List strNewline(String s, int len) {
		if (s == null) {
			return null;
		}

		try {

			List ls = new ArrayList();

			char ch;
			char ch1 = 13; // 回车

			int len2 = s.length();

			for (int i = 0; i < len2;) {
				int tempLen = 0;
				String newStr = "";
				while (tempLen < len && i < len2) {
					ch = s.charAt(i++);
					if (ch == ch1) {
						break;
					} else if (ch < 32) {
						continue;
					} else if (ch <= 256) {
						if (ch == '\\') {
							if (tempLen == len - 2) {
								tempLen--;
							} else {
								tempLen++;
							}
						} else {
							tempLen++;
						}
					} else if (ch > 256) {
						tempLen = tempLen + 2;
					}

					if (tempLen < len - 1) {
						newStr += ch;

					} else {
						newStr += ch;
						if (i < len2 && s.charAt(i) == ch1) {
							i++;
						}
						break;
					}
				}
				// System.out.println(newStr);
				ls.add(newStr);
			}
			return ls;
			// 只有英文
		} catch (Exception ex) {
			return null;
		}
	}

	/**
	 * 获取一个字符串的绝对长度(如果遇到汉字字符则算两个)
	 * 
	 * @param s
	 *            传入的字串
	 * 
	 * @return 字串的绝对长度
	 * 
	 */
	public static String substring(String s, int star, int len) {
		if (s == null) {
			return "";
		}
		try {
			String s1 = new String(s.getBytes("GBK"), "8859_1");
			s1 = CS(s1.substring(star, len));
			return s1;
		} catch (Exception e) {
			return "";
		}
	}

	/**
	 * 对一个字符串的绝对长度进行拆解(如果遇到汉字字符会把它当作两个字符处理)
	 * 
	 * @param s
	 *            传入的字串
	 * 
	 * @param start
	 *            起始绝对位置
	 * @param end
	 *            终止绝对位置
	 * @return 返回的字串
	 * 
	 */
	public static String absoluteSubstring(String s, int start, int end) {
		if (s == null) {
			return null;
		}
		try {
			String s2 = new String(s.getBytes("GBK"), "8859_1");
			s2 = s2.substring(start, end);
			return new String(s2.getBytes("8859_1"), "GBK");
		} catch (Exception e) {
			return s.substring(start, end);
		}
	}

	/**
	 * 判断一个字符是Ascill字符还是其它字符（如汉，日，韩文字符）
	 * 
	 * @param c
	 *            需要判断的字符
	 * @return 返回true,Ascill字符
	 */
	public static boolean isLetter(char c) {
		int k = 0x80;
		return c / k == 0 ? true : false;
	}

	/**
	 * 得到一个字符串的长度,显示的长度,一个汉字或日韩文长度为2,英文字符长度为1
	 * 
	 * @param s
	 *            需要得到长度的字符串
	 * @return i得到的字符串长度
	 */
	public static int length(String s) {
		if (s == null)
			return 0;
		char[] c = s.toCharArray();
		int len = 0;
		for (int i = 0; i < c.length; i++) {
			len++;
			if (!isLetter(c[i])) {
				len++;
			}
		}
		return len;
	}
}
